Please address the comments from this code review:
## Overall Comments
- The `brightness_to_u8` test calls `Brightness::from(i.0)` incorrectly – it should directly use `u8::from(i.0)` since you only implemented `From<Brightness> for u8`.
- Consider providing a builder-style `.brightness()` setter or allowing brightness to be modified on an existing `PayloadBuffer` for consistency with other style setters instead of only via the constructor.
- Changing the header size by removing a magic byte and inserting `brightness` breaks protocol compatibility; ensure you document this change clearly and bump the protocol version accordingly.

## Individual Comments

### Comment 1
<location> `src/protocol.rs:536` </location>
<code_context>
+            (Brightness::OneQuarter, 0x30),
+        ];
+
+        for i in VALID_BRIGHTNESS_VALUES {
+            assert_eq!(u8::from(Brightness::from(i.0)), i.1);
+        }
</code_context>

<issue_to_address>
Redundant use of Brightness::from in test.

You can simplify `u8::from(Brightness::from(i.0))` to `u8::from(i.0)` since `i.0` is already a Brightness.
</issue_to_address>

Please address the comments from this code review:
## Individual Comments

### Comment 1
<location> `src/protocol.rs:214` </location>
<code_context>
+    }
+}
+
+impl TryFrom<u8> for Brightness {
+    type Error = TryFromIntError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(match value {
+            0x00 => Self::Full,
+            0x10 => Self::ThreeQuarters,
+            0x20 => Self::Half,
+            0x30 => Self::OneQuarter,
+            _ => return Err(u8::try_from(-1).unwrap_err()),
+        })
+    }
</code_context>

<issue_to_address>
Using u8::try_from(-1) to generate an error is indirect and may be confusing.

Use a more explicit error, like core::num::TryFromIntError::default() or a custom error type, to clarify intent and avoid depending on u8::try_from(-1).
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
+impl TryFrom<u8> for Brightness {
+    type Error = TryFromIntError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(match value {
+            0x00 => Self::Full,
+            0x10 => Self::ThreeQuarters,
+            0x20 => Self::Half,
+            0x30 => Self::OneQuarter,
+            _ => return Err(u8::try_from(-1).unwrap_err()),
+        })
+    }
=======
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct BrightnessParseError;
+
+impl core::fmt::Display for BrightnessParseError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "invalid value for Brightness")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BrightnessParseError {}
+
+impl TryFrom<u8> for Brightness {
+    type Error = BrightnessParseError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0x00 => Ok(Self::Full),
+            0x10 => Ok(Self::ThreeQuarters),
+            0x20 => Ok(Self::Half),
+            0x30 => Ok(Self::OneQuarter),
+            _ => Err(BrightnessParseError),
+        }
+    }
>>>>>>> REPLACE

</suggested_fix>

### Comment 2
<location> `src/protocol.rs:342` </location>
<code_context>
+    }
+
     /// Return the current number of messages
     pub fn num_messages(&mut self) -> usize {
         self.num_messages as usize
</code_context>

<issue_to_address>
The num_messages method takes &mut self but does not mutate state.

Changing the receiver to &self would improve flexibility since no mutation occurs.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    /// Return the current number of messages
    pub fn num_messages(&mut self) -> usize {
        self.num_messages as usize
        &self.data
    }
=======
    /// Return the current number of messages
    pub fn num_messages(&self) -> usize {
        self.num_messages as usize
    }
>>>>>>> REPLACE

</suggested_fix>

Please address the comments from this code review:
## Overall Comments
- The TryFrom<u8> implementation for Brightness uses a workaround (`u8::try_from(-1).unwrap_err()`) to generate errors—consider defining a dedicated error type or using a more idiomatic approach for invalid values.
- Changing the protocol header (MAGIC length changed and a brightness byte added) is a breaking change—make sure the version bump follows semver (major version) or include upgrade notes.
- Consider adding unit tests for invalid brightness inputs to verify that TryFrom<u8> correctly returns Err for out-of-range values.